{
  LW Image -- LightWave Image Handlers

  Based on lwimage.h which is:
  Copyright 1999, NewTek, Inc.
}

{
  Copyright 2012, Jameel Halabi

  This unit is part of the BlaiseWave wrapper,
  which is licensed under the BSD 2-Clause license (see licenses/license.txt).
}

unit LW_Image;

{$mode objfpc}{$H+}

interface

uses
  LW_Types,
  LW_ImageIO,
  LW_IO;

type

  { Change-event codes }
  ChangeEventCodes = ( LWCEV_CHANGE := 0 ,
                       LWCEV_REPLACE     ,
                       LWCEV_DESTROY     ) ;

  { Change-event callback prototype }
  PLWImageEventFunc = procedure
                      ( eventCode : Integer ;
                        Img       : PLWImage ) of object;

  { Event regitration codes (second argument to changeEvent())}
  EventRegCodes    = ( LWERC_REGISTER := 0 ,
                       LWERC_UNREGISTER    ) ;

  { When surface plugins save an image in an LWO, it is necessare to call
    clipSetMark to tell the LWO saver which clips are being saved. }

  { Prototype for the save notify callback. }
  PLWImageSaverNotify = function ( Instance: PLWInstance ) : PLWImage of object;

  TLWImageList = record
    First       : function
                  ( const Void                    ) : PLWImage;
    Next        : function
                  (       Img      : PLWImage     ) : PLWImage;
    Load        : function
                  ( const Filename : PChar        ) : PLWImage;
    Name        : function
                  (       Img      : PLWImage     ) : PChar   ; // const
    Filename    : function
                  (       Img      : PLWImage     ;
                          Frame    : TLWFrame     ) : PChar; // const
    IsColor     : function
                  (       Img      : PLWImage     ) : Integer;
    NeedAA      : procedure
                  (       Img      : PLWImage     );
    Size        : procedure
                  (       Img      : PLWImage     ;
                          W                       ,
                          H        : PInteger     );
    Luma        : function
                  (       Img      : PLWImage     ;
                          X                       ,
                          Y        : Integer      ) : TLWBufferValue;
    RGB         : procedure
                  (       Img      : PLWImage     ;
                          X                       ,
                          Y        : Integer      ;
                          values   : array {[0..2]} of TLWBufferValue );
    LumaSpot    : function
                  (       Img      : PLWImage     ;
                          X                       ,
                          Y                       ,
                          SpotSize : Double       ;
                          InBlend  : Integer      ) : Double;
    RGBSpot     : procedure
                  (       Img      : PLWImage     ;
                          X                       ,
                          Y                       ,
                          SpotSize : Double       ;
                          InBlend  : Integer      ;
                          RGB      : array {[0..2]} of Double);
    Clear       : procedure
                  (       Img      : PLWImage     ) ;
    SceneLoad   : function
                  ( const Load     : PLWLoadState ) : PLWImage;
    SceneSave   : procedure
                  ( const Save     : PLWSaveState ;
                          Img      : PLWImage     ) ;
    HasAlpha    : function
                  (       Img      : PLWImage     ) : Integer;
    Alpha       : function
                  (       Img      : PLWImage     ;
                          X                       ,
                          Y        : Integer      ) : TLWBufferValue;
    AlphaSpot   : function
                  (       Img      : PLWImage     ;
                          X                       ,
                          Y                       ,
                          SpotSize : Double       ;
                          InBlend  : Integer      ) : Double;
    Evaluate    : function
                  (       Img      : PLWImage     ;
                          T        : TLWTime      ) : PLWPixmap;
    ChangeEvent : procedure
                  (       Func     : PLWImageEventFunc ;
                          Code     : Integer      );
    Replace     : function
                  (       Img      : PLWImage     ;
                    const Filename : PChar        ) : Integer;
    Create      : function
                  ( const Name     : PChar        ;
                          Width                   ,
                          Height   : Integer      ;
                          Type_    : TLWImageType ) : PLWPixmap;
    SaverNotifyAttach    : procedure
                           ( Instance       : PLWInstance        ;
                             SaverNotify    : PLWImageSaverNotify ) ;
    SaverNotifyDetach    : procedure
                           ( Instance       : PLWInstance        ) ;
    SaverNotifyMarkUsage : procedure
                           ( Texture        : PLWTexture         ) ;
  end;

  TLWImageUtil = record
    Create        : function
                    (       W                    ,
                            H     : Integer      ;
                            Type_ : TLWImageType ) : PLWPixmap;
    Destroy       : procedure
                    (       Img   : PLWPixmap    ) ;
    Save          : function
                    (       Img   : PLWPixmap    ;
                            Saver : Integer      ;
                      const Name  : PChar        ) : Integer;
    SetPixel      : procedure
                    (       Img   : PLWPixmap    ;
                            X                    ,
                            Y     : Integer      ;
                            Pix   : Pointer      ) ;
    GetPixel      : procedure
                    (       Img   : PLWPixmap    ;
                            X                    ,
                            Y     : Integer      ;
                            Pix   : Pointer      ) ;
    GetInfo       : procedure
                    (       Img   : PLWPixmap    ;
                            W                    ,
                            H     : PInteger     ;
                            Type_ : PInteger     ) ;
    Resample      : function
                    (       Img   : PLWPixmap    ;
                            W                    ,
                            H     :   Integer    ;
                            Mode  : Integer      ) : PLWPixmap;
    SaverCount    : function
                    ( const Void                 ) : Integer;
    SaverName     : function
                    (       Saver : Integer      ) : PChar;  //const
    SetPixelTyped : procedure
                    (       Img   : PLWPixmap    ;
                            X                    ,
                            Y     : Integer      ;
                            Type_ : Integer      ;
                            pix   : Pointer      );
    GetPixelTyped : procedure
                    (       Img   : PLWPixmap    ;
                            X                    ,
                            Y     : Integer      ;
                            Type_ : Integer      ;
                            pix   : Pointer      );
    GetIndex8Map  : function
                    (         Img   : PLWPixmap      ;
                              Map   : PLWPixelRGB24 ) : Integer;
    GetAttr       : function
                    (         Img   : PLWPixmap      ;
                              Tag   : TLWImageParam  ;
                              Data  : Pointer        ) : Integer;
    GetMakerNote  : function
                    (         Img   : PLWPixmap      ;
                              Tag   : TLWMakerNote   ;
                              Data  : Pointer        ) : Integer;
  end;

  { Resample modes }
  ResampleModes = ( LWISM_SUBSAMPLING := 0 ,
                    LWISM_MEDIAN           , { for shrinking *}
                    LWISM_SUPERSAMPLING    ,
                    LWISM_BILINEAR 	   , { for expanding }
                    LWISM_BSPLINE          , { for expanding }
                    LWISM_BICUBIC	   ) ; { for expanding }


implementation

end.

